import 'dart:convert';
import 'api_response.dart';
import '../utils/json_utils.dart';
import 'package:flutter/foundation.dart';

/// 物模型信息
class ThingModel {
  int? modelId;
  int? productId;
  String? modelVersion;
  int? modelStatus;
  dynamic modelJson; // 可以是字符串或JSON对象
  String? createBy;
  String? createTime;
  String? updateBy;
  String? updateTime;
  String? tenantId;
  String? remark;

  ThingModel({
    this.modelId,
    this.productId,
    this.modelVersion,
    this.modelStatus,
    this.modelJson,
    this.createBy,
    this.createTime,
    this.updateBy,
    this.updateTime,
    this.tenantId,
    this.remark,
  });

  ThingModel.fromJson(Map<String, dynamic> json) {
    modelId = json['modelId'];
    productId = json['productId'];
    modelVersion = json['modelVersion'];
    modelStatus = json['modelStatus'];
    
    // 特殊处理modelJson字段
    if (json.containsKey('modelJson')) {
      var rawModelJson = json['modelJson'];
      
      // 记录原始类型用于调试
      debugPrint('原始modelJson类型: ${rawModelJson?.runtimeType}');
      
      if (rawModelJson is String) {
        // 如果是字符串，可能是被转义或序列化过的JSON
        if (rawModelJson.trim().startsWith('{')) {
          // 尝试解析JSON字符串
          try {
            // 先尝试简单解析
            modelJson = jsonDecode(rawModelJson);
            debugPrint('成功解析modelJson字符串为Map');
          } catch (e) {
            // 如果简单解析失败，使用增强解析
            try {
              modelJson = JsonUtils.parseEscapedJsonString(rawModelJson);
              debugPrint('使用增强解析成功解析modelJson');
            } catch (e2) {
              // 解析失败，保持原始字符串
              debugPrint('JSON解析失败，保留原始字符串: $e2');
              modelJson = rawModelJson;
            }
          }
        } else {
          // 不是标准JSON格式，保持原样
          modelJson = rawModelJson;
        }
      } else {
        // 非字符串类型，直接使用
        modelJson = rawModelJson;
      }
    } else {
      modelJson = null;
    }
    
    createBy = json['createBy'];
    createTime = json['createTime'];
    updateBy = json['updateBy'];
    updateTime = json['updateTime'];
    tenantId = json['tenantId'];
    remark = json['remark'];
  }

  Map<String, dynamic> toJson() {
    final Map<String, dynamic> data = <String, dynamic>{};
    data['modelId'] = modelId;
    data['productId'] = productId;
    data['modelVersion'] = modelVersion;
    data['modelStatus'] = modelStatus;
    data['modelJson'] = modelJson;
    data['createBy'] = createBy;
    data['createTime'] = createTime;
    data['updateBy'] = updateBy;
    data['updateTime'] = updateTime;
    data['tenantId'] = tenantId;
    data['remark'] = remark;
    return data;
  }
  
  /// 获取解析后的物模型JSON数据
  Map<String, dynamic> getParsedModelJson() {
    if (modelJson == null) return {};
    
    try {
      debugPrint('尝试解析物模型JSON - 类型: ${modelJson.runtimeType}');
      
      // 处理特殊情况：如果modelJson是一个包含外层属性的完整对象
      if (modelJson is Map && modelJson.containsKey('properties')) {
        debugPrint('检测到modelJson已经是包含properties的Map');
        return modelJson as Map<String, dynamic>;
      }
      
      // 使用JsonUtils工具类将各种格式的modelJson转换为Map
      var result = JsonUtils.toMap(modelJson);
      
      // 如果解析结果为空但原始数据不为空，尝试直接使用
      if (result.isEmpty && modelJson is Map && (modelJson as Map).isNotEmpty) {
        debugPrint('JsonUtils解析为空，但原始数据不为空，尝试直接使用');
        return Map<String, dynamic>.from(modelJson as Map);
      }
      
      return result;
    } catch (e) {
      debugPrint('物模型JSON解析错误: $e');
      debugPrint('物模型JSON原始数据类型: ${modelJson.runtimeType}');
      
      // 最后尝试：如果modelJson是Map但不是Map<String, dynamic>，进行转换
      if (modelJson is Map) {
        try {
          debugPrint('尝试将Map转换为Map<String, dynamic>');
          return Map<String, dynamic>.from(modelJson);
        } catch (e2) {
          debugPrint('Map转换失败: $e2');
        }
      }
      
      return {};
    }
  }
  
  /// 从带转义字符的JSON字符串创建ThingModel对象
  static ThingModel fromRawJson(String jsonString) {
    try {
      // 先尝试解析整个对象
      Map<String, dynamic> data = JsonUtils.parseEscapedJsonString(jsonString);
      return ThingModel.fromJson(data);
    } catch (e) {
      // 如果失败，可能只有modelJson部分是一个JSON字符串
      print('无法解析完整ThingModel，尝试只解析modelJson部分: $e');
      
      // 创建一个基础的ThingModel，并设置modelJson
      ThingModel model = ThingModel();
      // 假设传入的字符串就是modelJson部分
      model.modelJson = jsonString;
      return model;
    }
  }
  
  /// 设置物模型JSON数据
  void setModelJson(dynamic json) {
    if (json is Map) {
      // 如果传入的是Map，则转换为JSON字符串
      try {
        modelJson = jsonEncode(json);
      } catch (e) {
        modelJson = json;
      }
    } else if (json is String) {
      // 验证是否为有效的JSON字符串
      try {
        jsonDecode(json);
        modelJson = json;
      } catch (e) {
        print('无效的JSON字符串: $e');
      }
    } else {
      modelJson = json;
    }
  }
}

/// 物模型列表响应
class ThingModelListResponse {
  final int total;
  final List<ThingModel> rows;
  final int code;
  final String msg;

  ThingModelListResponse({
    required this.total,
    required this.rows,
    required this.code,
    required this.msg,
  });

  factory ThingModelListResponse.fromJson(Map<String, dynamic> json) {
    List<ThingModel> parsedRows = [];
    
    try {
      if (json.containsKey('rows') && json['rows'] is List) {
        parsedRows = (json['rows'] as List)
            .map((item) => ThingModel.fromJson(item as Map<String, dynamic>))
            .toList();
      }
      
      // 调试日志
      debugPrint('ThingModelListResponse解析: total=${json['total']}, rows=${parsedRows.length}, code=${json['code']}');
      
      return ThingModelListResponse(
        total: json['total'] ?? 0,
        rows: parsedRows,
        code: json['code'] ?? 500,
        msg: json['msg'] ?? '未知错误',
      );
    } catch (e) {
      debugPrint('ThingModelListResponse解析错误: $e');
      // 返回一个空响应而不是抛出异常
      return ThingModelListResponse(
        total: 0,
        rows: [],
        code: 500,
        msg: '解析错误: $e',
      );
    }
  }
}

/// 物模型详情响应
class ThingModelDetailResponse extends ApiResponse<ThingModel> {
  ThingModelDetailResponse({
    required int code,
    required String msg,
    ThingModel? data,
  }) : super(code: code, msg: msg, data: data);

  factory ThingModelDetailResponse.fromJson(Map<String, dynamic> json) {
    return ThingModelDetailResponse(
      code: json['code'],
      msg: json['msg'],
      data: json['data'] != null ? ThingModel.fromJson(json['data']) : null,
    );
  }
} 